.TH std::basic_spanbuf::basic_spanbuf 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::basic_spanbuf::basic_spanbuf \- std::basic_spanbuf::basic_spanbuf

.SH Synopsis
   basic_spanbuf() : basic_spanbuf(std::ios_base::in |                \fB(1)\fP (since C++23)
   std::ios_base::out) {}
   explicit basic_spanbuf( std::ios_base::openmode which )            \fB(2)\fP (since C++23)
       : basic_spanbuf(std::span<CharT>{}, which) {}
   explicit basic_spanbuf( std::span<CharT> buf,
   std::ios_base::openmode which =                                    \fB(3)\fP (since C++23)
                               std::ios_base::in | std::ios_base::out
   );
   basic_spanbuf( const basic_spanbuf& ) = delete;                    \fB(4)\fP (since C++23)
   basic_spanbuf( basic_spanbuf&& rhs );                              \fB(5)\fP (since C++23)

   1) Default constructor. Creates a basic_spanbuf that has no underlying buffer and is
   opened for both input and output. The pointers to get and put area are set to the
   null pointer value.
   2) Same as \fB(1)\fP, except that the basic_spanbuf is opened in mode specified by which.
   3) Creates a basic_spanbuf that manages the underlying buffer referenced by buf (or
   has no underlying buffer if buf is empty) and is opened in mode specified by which.
   The pointers to get and put area are set as following, or to the null pointer value
   if not mentioned in the table:

           Set bits in open mode                   Return value after setting
     (affecting pointers to get area)    eback()  gptr()             egptr()
   std::ios_base::in                     s.data() s.data()           s.data() +
                                                                     s.size()
           Set bits in open mode                   Return value after setting
     (affecting pointers to put area)    pbase()  pptr()             epptr()
   std::ios_base::out &&                 s.data() s.data()           s.data() +
   !std::ios_base::ate                                               s.size()
   std::ios_base::out &&                 s.data() s.data() +         s.data() +
   std::ios_base::ate                             s.size()           s.size()

   4) Copy constructor is deleted. basic_spanbuf is not copyable.
   5) Move constructor. Move-constructs the std::basic_streambuf base subobject from
   that of rhs. The pointers to get and put area, the open mode, and the underlying
   buffer (if any) are identical to those in rhs before construction.
   It is implementation-defined whether rhs still holds the underlying buffer after the
   move-construction.

.SH Parameters

   buf   - a std::span referencing the underlying buffer
   rhs   - another basic_spanbuf
           specifies stream open mode. It is bitmask type, the following constants are
           defined:

           Constant          Explanation
           app               seek to the end of stream before each write
   which - binary            open in binary mode
           in                open for reading
           out               open for writing
           trunc             discard the contents of the stream when opening
           ate               seek to the end of stream immediately after open
           noreplace (C++23) open in exclusive mode

.SH Notes

   These constructors are typically called by the constructors of
   std::basic_ispanstream, std::basic_ospanstream, and std::basic_spanstream.

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   constructor   constructs the basic_ispanstream
   (C++23)       \fI(public member function of std::basic_ispanstream<CharT,Traits>)\fP

   constructor   constructs the basic_ospanstream
   (C++23)       \fI(public member function of std::basic_ospanstream<CharT,Traits>)\fP

   constructor   constructs the basic_spanstream
   (C++23)       \fI(public member function of std::basic_spanstream<CharT,Traits>)\fP

.SH Category:
     * Todo no example
